public class DB数据库操作{

  
  public static java.util.List<android.database.sqlite.SQLiteDatabase> db = new java.util.ArrayList<android.database.sqlite.SQLiteDatabase>();
  public static java.util.List<String> error = new java.util.ArrayList<String>();
 
  
/*
打开一个DB数据库，如果不存在则自动创建，成功返回数据库在集合中的位置，失败返回-1。整数型
参数<1>为宿主的上下文对象。上下文；
参数<2>为数据库名称或路径。文本型。
*/
  public static int 打开数据库(android.content.Context con,String DBName){
    try
    {
      android.database.sqlite.SQLiteDatabase base;
      java.io.File file = new java.io.File(DBName);
      if(file.exists()){
         base = con.openOrCreateDatabase(DBName, 0, null);
      }else{
         base = con.openOrCreateDatabase(DBName, 0, null);
      }
      db.add(base);
      return db.size()-1;
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return -1;
  }//★

/*
关闭一个已经打开DB数据库，并从集合中删除，释放内存。成功返回真，失败返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型。
*/ 
  public static boolean 关闭数据库(int index) {
    try {
      if(index > -1 && index < db.size()){
        db.get(index).close();
        return true;
      }
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return false;
  }//★

/*
创建一个DB数据库的数据表，成功返回真，失败返回假。逻辑型。
参数<1>为要创建的数据表名。文本型；
参数<2>为当前数据库在集合中的位置。整数型；
参数<3>为待被创建的表的SQL数据，如：id INTEGER PRIMARY KEY,USER_ID TEXT,USER_NAME TEXT。文本型。
*/ 
  public static boolean 创建数据表(String bm, int index, String lx)
  {
    try {
      db.get(index).execSQL("CREATE TABLE " + bm + " (" + lx + ")");
      return true;
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return false;
  }//★

/*
判断数据表是否存在，返回逻辑型。
参数<1>为数据库索引。整数型。
参数<2>为数据表名。文本型。
*/ 
  public static boolean 数据表是否存在(int index,String tabName){
        boolean result = false;
        if(tabName == null || tabName.equals("") || index < 0 || index >= db.size()){
	   return false;
        }
       android.database.Cursor cursor = null;
       try {
              String sql = "select count(*) as c from sqlite_master where type ='table' and name ='"+tabName.trim()+"'";
              cursor = db.get(index).rawQuery(sql, null);
              if(cursor.moveToNext()){
	     int count = cursor.getInt(0);
	     if(count>0){
	             result = true;
	      }
              }
       } catch (Exception e) {
          error.add(e.getMessage());
          e.printStackTrace();
       }                
    return result;
  }//★

/*
删除一个DB数据库的数据表，成功返回真，失败返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为待被删除的数据表名。文本型。
*/  
  public static boolean 删除数据表(int index, String BM) {
    try {
      db.get(index).execSQL("DROP TABLE " + BM);
      return true;
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return false;
  }//★

/*
向当前DB数据库的指定数据表插入一条记录，成功返回真，失败返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为表字段数据，可以是SQL语句，如：testTable(name,age)。文本型；
参数<3>为记录数据，可以是SQL语句，文本记录需要添加单引号，如：'zhangsan',23。文本型。
*/    
  public static boolean 插入记录(int index, String BM, String nr) {
    try {
      db.get(index).execSQL("INSERT INTO " + BM + " VALUES (" + nr + ")");
      return true;
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return false;
  }//★
  
/*
删除当前DB数据库的指定数据表中的指定记录，成功返回真，失败返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为表数据，可以是SQL语句，如：testTable。文本型；
参数<3>为条件数据，可以是SQL语句，如：age > 1。文本型。
*/  
  public static boolean 删除记录(int index, String BM, String hz) {
    try {
      db.get(index).execSQL("DELETE FROM " + BM + " WHERE " + hz);
      return true;
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return false;
  }//★

/*
修改当前DB数据库的指定数据表中的指定记录，成功返回真，失败返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为表数据，可以是SQL语句，如：testTable。文本型；
参数<3>为记录赋值数据，可以是SQL语句，如：name='zhangsan'。文本型；
参数<4>为记录定位数据，可以是SQL语句，如：id=1。文本型。
*/  
  public static boolean 修改记录(int index, String BM, String xz, String yn){
    try {
      db.get(index).execSQL("UPDATE " + BM + " SET " + xz + " WHERE " + yn);
      return true;
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return false;
  }//★

/*
根据条件查询当前DB数据库的指定数据表中的记录，成功返回结果文本数组，失败返回空文本数组。文本型数组。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为表数据，可以是SQL语句，如：testTable。文本型；
参数<3>为查询数据，可以是SQL语句，如：name='zhangsan'。文本型。
*/ 
  public static String[] 条件查询(int index, String BM, String hz){

    android.database.Cursor cursor = null;
    java.util.List<String> tmpvalue = new java.util.ArrayList<String>();
    try {
      cursor = db.get(index).rawQuery("SELECT * FROM " + BM + " WHERE " + hz, null);
      while (cursor.moveToNext())
      {
        int columnCount = cursor.getColumnCount();
        for (int i = 0; i < columnCount; i++) {
          String tmp = cursor.getString(i);
          tmpvalue.add(tmp);
        }
      }
     if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    catch (Exception e)
    {
      if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    finally
    {
      if ((null != cursor) && (!cursor.isClosed())) {
        cursor.close();
      }
    }
    if(tmpvalue != null && tmpvalue.size() > 0){
       String[] res = new String[tmpvalue.size()];
       for(int i=0;i<tmpvalue.size();i++){
          res[i] = tmpvalue.get(i);
       }
       return res;
     }
    return new String[0];
  }//★

/*
根据记录范围查询当前DB数据库的指定数据表中的记录，成功返回结果文本数组，失败返回空文本数组。文本型数组。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为表数据，可以是SQL语句，如：testTable。文本型；
参数<3>为起始记录位置。整数型；
参数<4>为结束记录位置。整数型。
*/   
  public static String[] 范围查询(int index, String BM, int from, int to){

    java.util.List<String> tmpvalue = new java.util.ArrayList<String>();
    android.database.Cursor cursor = null;
    try {
      cursor = db.get(index).rawQuery("SELECT * FROM " + BM + " LIMIT " + Integer.toString(from) + "," + Integer.toString(to), null);
      while (cursor.moveToNext())
      {
        int columnCount = cursor.getColumnCount();
        for (int i = 0; i < columnCount; i++) {
          tmpvalue.add(cursor.getString(i));
        }
      }

    if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    catch (Exception e)
    {
      if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    finally
    {
      if ((null != cursor) && (!cursor.isClosed())) {
        cursor.close();
      }
    }
    if(tmpvalue != null && tmpvalue.size() > 0){
       String[] res = new String[tmpvalue.size()];
       for(int i=0;i<tmpvalue.size();i++){
          res[i] = tmpvalue.get(i);
       }
       return res;
     }
    return new String[0];
  }//★

/*
在当前DB数据库中执行SQL查询语句(以“select”打头)，成功返回结果文本数组，失败返回空文本数组。文本型数组。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为SQL查询语句。文本型。
*/  
  public static String[] 数据库查询(int index, String SQLSen)
  {
    java.util.List<String> tmpvalue = new java.util.ArrayList<String>();
    android.database.Cursor cursor = null;
    try {
      cursor = db.get(index).rawQuery(SQLSen, null);
      while (cursor.moveToNext())
      {
        int columnCount = cursor.getColumnCount();
        for (int i = 0; i < columnCount; i++) {
          tmpvalue.add(cursor.getString(i));
        }
      }

    if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    catch (Exception e)
    {
      if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    finally
    {
      if ((null != cursor) && (!cursor.isClosed())) {
        cursor.close();
      }
    }
    if(tmpvalue != null && tmpvalue.size() > 0){
       String[] res = new String[tmpvalue.size()];
       for(int i=0;i<tmpvalue.size();i++){
          res[i] = tmpvalue.get(i);
       }
       return res;
     }
    return new String[0];
  }//★

/*
在当前DB数据库中执行SQL语句，成功返回真，失败返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为SQL语句。文本型。
*/    
  public static boolean 数据库执行(int index, String SQLSen)
  {
    try {
      db.get(index).execSQL(SQLSen);
      return true;
    }
    catch (Exception e) {
       error.add(e.getMessage());
       e.printStackTrace();
    }
   return false;
  }//★

/*
取当前DB数据库中指定表的记录数量，成功返回记录数，失败返回-1。长整数。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为数据表名。文本型。
*/ 
  public static long 取记录数(int index, String TBName) {
    long count = 0L;
    android.database.Cursor cursor = null;
    try {
      cursor = db.get(index).rawQuery("select count(*)from " + TBName, null);
      cursor.moveToFirst();
      count = cursor.getLong(0);
      if ((null != cursor) && (!cursor.isClosed())){
        cursor.close();
      }
       return count;
    }
    catch (Exception e)
    {
      if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    finally
    {
      if ((null != cursor) && (!cursor.isClosed())) {
        cursor.close();
      }
    }
    return -1;
  }//★

/*
判断当前DB数据库中指定表是否存在，存在返回真，不存在返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为数据表名。文本型。
*/ 
  public static boolean 数据表是否存在(int index, String TBName)
  {
    int count = 0;
    android.database.Cursor cursor = null;
    try {
      cursor = db.get(index).rawQuery("SELECT count(*) FROM sqlite_master WHERE type='table' AND name='" + TBName + "'", null);
      cursor.moveToFirst();
      count = cursor.getInt(0);

      if ((null != cursor) && (!cursor.isClosed())){
        cursor.close();
      }
    }
    catch (Exception e)
    {
      if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    finally
    {
      if ((null != cursor) && (!cursor.isClosed())) {
        cursor.close();
      }
    }
    if (count > 0) {
      return true;
    }
    return false;
  }//★

/*
判断当前DB数据库中指定表的指定字段是否存在，存在返回真，不存在返回假。逻辑型。
参数<1>为当前数据库在集合中的位置。整数型；
参数<2>为指定数据表名。文本型；
参数<3>为指定字段名。文本型。
*/ 
  public static boolean 字段是否存在(int index, String tableName, String columnName)
  {
    boolean result = false;
    android.database.Cursor cursor = null;
    try
    {
      cursor = db.get(index).rawQuery("SELECT * FROM " + tableName + " LIMIT 0", null);
      result = (cursor != null) && (cursor.getColumnIndex(columnName) != -1);

      if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    catch (Exception e)
    {
      if ((null != cursor) && (!cursor.isClosed()))
        cursor.close();
    }
    finally
    {
      if ((null != cursor) && (!cursor.isClosed())) {
        cursor.close();
      }
    }
    return result;
  }//★

/*
取当前DB数据库中所有表名，成功返回表名的文本数组，失败返回空文本数组。文本型数组。
参数<1>为当前数据库在集合中的位置。整数型。
*/   
  public static String[] 取所有数据表(int index)
  {
    android.database.Cursor cursor1 = db.get(index).rawQuery("SELECT count(*) FROM sqlite_master WHERE type='table'", null);
    cursor1.moveToFirst();
    int count = cursor1.getInt(0);
    cursor1.close();
    android.database.Cursor cursor2 = db.get(index).rawQuery("select name from sqlite_master where type='table' order by name", null);
    cursor2.moveToFirst();
    String[] result = new String[count];
    int temp = 0;
    while (cursor2.moveToNext()) {
      String name = cursor2.getString(0);
      result[temp] = name;
      temp += 1;
    }
    cursor2.close();
    return result;
  }//★
}

/*
如果当前某条DB数据库操作命令产生错误信息，本命令用以获取，返回文本型。
*/ 
  public static String 获取当前错误信息(){
     if(error.size() > 0 ){
        return error.get(error.size()-1);
     }
     return "";
  }//★

/*
如果当前某条DB数据库操作命令产生错误信息，本命令用以获取，返回文本型。
*/ 
  public static String 获取所有错误信息(){
     String result = "";
     for(int a=0;a<error.size();a++){
        result = result + "\n" + error.get(a);
     }
     return result;
  }//★

/*权限
创建数据库:android.permission.WRITE_EXTERNAL_STORAGE,android.permission.MOUNT_UNMOUNT_FILESYSTEMS
权限*/

